/**
 * 字体相关CSS规则模块
 * @version 1.0.0
 */

import { utils } from '../../../utils/utils.js';
import { processTextEllipsisRules } from './text-ellipsis.js';

// 处理字体相关的CSS规则
export function processTypographyRules(className, options = {}) {
    const { platform = 'H5', h5Unit = 'rem', remBase = 16 } = options;
    
    // 字体大小
    const textSizeMatch = className.match(/^text-(.+)$/);
    if (textSizeMatch) {
        const value = textSizeMatch[1];
        
        // 处理带单位的字体大小 (如: text-16rpx, text-1.5rem)
        const unitMatch = value.match(/^(\d+(?:\.\d+)?)(rpx|px|rem|em|vh|vw|vmin|vmax|%|pt|pc|in|mm|cm)$/);
        if (unitMatch) {
            const [, numValue, unit] = unitMatch;
            
            // uni-app x 只支持 number|pixel
            if (platform === 'APP-PLUS' || platform === 'APP-ANDROID' || platform === 'APP-IOS') {
                if (unit === 'rem') {
                    return { 'font-size': `${numValue * remBase}px` };
                } else if (unit === 'em') {
                    return { 'font-size': `${numValue * 16}px` };
                } else if (unit === 'vw' || unit === 'vh') {
                    return { 'font-size': `${numValue * 3.75}px` };
                } else if (unit === 'rpx') {
                    return { 'font-size': `${numValue}rpx` }; // rpx在APP端也支持
                } else if (unit === 'px') {
                    return { 'font-size': `${numValue}px` };
                } else {
                    // 其他单位转换为px
                    return { 'font-size': `${numValue * 16}px` };
                }
            } else {
                return { 'font-size': `${numValue}${unit}` };
            }
        }
        // 处理纯数字值
        else if (utils.isNumber(value)) {
            return { 'font-size': utils.convertUnit(value, platform, { h5Unit, remBase, unitType: 'fontSize' }) };
        }
    }
    
    // 字体大小预设
    const getFontSize = (pxValue) => {
        if (platform === 'H5' && h5Unit === 'rem') {
            return `${pxValue / remBase}rem`;
        }
        return `${pxValue}px`;
    };
    
    const fontSizeMap = {
        'text-xs': getFontSize(12),
        'text-sm': getFontSize(14),
        'text-base': getFontSize(16),
        'text-lg': getFontSize(18),
        'text-xl': getFontSize(20),
        'text-2xl': getFontSize(24),
        'text-3xl': getFontSize(30),
        'text-4xl': getFontSize(36)
    };
    
    if (fontSizeMap[className]) {
        return { 'font-size': fontSizeMap[className] };
    }
    
    // 行高
    const lineHeightMatch = className.match(/^leading-(.+)$/);
    if (lineHeightMatch) {
        const value = lineHeightMatch[1];
        
        // 处理带单位的行高 (如: leading-20rpx, leading-1.5rem)
        const unitMatch = value.match(/^(\d+(?:\.\d+)?)(rpx|px|rem|em|vh|vw|vmin|vmax|%|pt|pc|in|mm|cm)$/);
        if (unitMatch) {
            const [, numValue, unit] = unitMatch;
            
            // uni-app x 只支持 number|pixel
            if (platform === 'APP-PLUS' || platform === 'APP-ANDROID' || platform === 'APP-IOS') {
                if (unit === 'rem') {
                    return { 'line-height': `${numValue * remBase}px` };
                } else if (unit === 'em') {
                    return { 'line-height': `${numValue * 16}px` };
                } else if (unit === 'vw' || unit === 'vh') {
                    return { 'line-height': `${numValue * 3.75}px` };
                } else if (unit === 'rpx') {
                    return { 'line-height': `${numValue}rpx` };
                } else if (unit === 'px') {
                    return { 'line-height': `${numValue}px` };
                } else {
                    // 其他单位转换为px
                    return { 'line-height': `${numValue * 16}px` };
                }
            } else {
                return { 'line-height': `${numValue}${unit}` };
            }
        }
        // 处理纯数字值（无单位，相对于字体大小）
        else if (utils.isNumber(value)) {
            return { 'line-height': value };
        }
        // 处理预设值
        else {
            const lineHeightMap = {
                'none': '1',
                'tight': '1.25',
                'snug': '1.375',
                'normal': '1.5',
                'relaxed': '1.625',
                'loose': '2'
            };
            if (lineHeightMap[value]) {
                return { 'line-height': lineHeightMap[value] };
            }
        }
    }
    
    // 字间距
    const letterSpacingMatch = className.match(/^tracking-(.+)$/);
    if (letterSpacingMatch) {
        const value = letterSpacingMatch[1];
        
        // 处理带单位的字间距 (如: tracking-2rpx, tracking-0.1em)
        const unitMatch = value.match(/^(\d+(?:\.\d+)?)(rpx|px|rem|em|vh|vw|vmin|vmax|%|pt|pc|in|mm|cm)$/);
        if (unitMatch) {
            const [, numValue, unit] = unitMatch;
            
            // uni-app x 只支持 number|pixel
            if (platform === 'APP-PLUS' || platform === 'APP-ANDROID' || platform === 'APP-IOS') {
                if (unit === 'rem') {
                    return { 'letter-spacing': `${numValue * remBase}px` };
                } else if (unit === 'em') {
                    return { 'letter-spacing': `${numValue * 16}px` };
                } else if (unit === 'vw' || unit === 'vh') {
                    return { 'letter-spacing': `${numValue * 3.75}px` };
                } else if (unit === 'rpx') {
                    return { 'letter-spacing': `${numValue}rpx` };
                } else if (unit === 'px') {
                    return { 'letter-spacing': `${numValue}px` };
                } else {
                    // 其他单位转换为px
                    return { 'letter-spacing': `${numValue * 16}px` };
                }
            } else {
                return { 'letter-spacing': `${numValue}${unit}` };
            }
        }
        // 处理预设值
        else {
            const letterSpacingMap = {
                'tighter': '-0.05em',
                'tight': '-0.025em',
                'normal': '0em',
                'wide': '0.025em',
                'wider': '0.05em',
                'widest': '0.1em'
            };
            if (letterSpacingMap[value]) {
                const spacingValue = letterSpacingMap[value];
                // uni-app x 中转换em为px
                if (platform === 'APP-PLUS' || platform === 'APP-ANDROID' || platform === 'APP-IOS') {
                    const emMatch = spacingValue.match(/^(-?\d+(?:\.\d+)?)em$/);
                    if (emMatch) {
                        return { 'letter-spacing': `${parseFloat(emMatch[1]) * 16}px` };
                    }
                }
                return { 'letter-spacing': spacingValue };
            }
        }
    }
    
    // 文本对齐
    const textAlignMap = {
        'text-left': 'left',
        'text-center': 'center',
        'text-right': 'right',
        'text-justify': 'justify'
    };
    
    if (textAlignMap[className]) {
        return { 'text-align': textAlignMap[className] };
    }
    
    // 字体粗细
    const fontWeightMap = {
        'font-thin': '100',
        'font-light': '300',
        'font-normal': '400',
        'font-medium': '500',
        'font-semibold': '600',
        'font-bold': '700',
        'font-black': '900'
    };
    
    if (fontWeightMap[className]) {
        let fontWeight = fontWeightMap[className];
        
        // uni-app x 只支持 normal|bold|400|700
        if (platform === 'APP-PLUS' || platform === 'APP-ANDROID' || platform === 'APP-IOS') {
            if (['100', '300'].includes(fontWeight)) {
                fontWeight = 'normal';
            } else if (['500', '600', '700', '900'].includes(fontWeight)) {
                fontWeight = 'bold';
            }
        }
        
        return { 'font-weight': fontWeight };
    }
    
    // 字体家族 - 根据 uni-app x 文档支持
    const fontFamilyMap = {
        'font-sans': 'sans-serif',
        'font-serif': 'serif',
        'font-mono': 'monospace',
        'font-cursive': 'cursive',
        'font-fantasy': 'fantasy',
        'font-icon': 'uni-icon' // uni-app x 内置字体图标
    };
    
    if (fontFamilyMap[className]) {
        return { 'font-family': fontFamilyMap[className] };
    }
    
    // 字体样式
    const fontStyleMap = {
        'italic': 'italic',
        'not-italic': 'normal'
    };
    
    if (fontStyleMap[className]) {
        return { 'font-style': fontStyleMap[className] };
    }
    
    // 文本装饰
    const textDecorationMap = {
        'underline': 'underline',
        'overline': 'overline',
        'line-through': 'line-through',
        'no-underline': 'none'
    };
    
    if (textDecorationMap[className]) {
        return { 'text-decoration-line': textDecorationMap[className] };
    }
    
    // 文本变换
    const textTransformMap = {
        'uppercase': 'uppercase',
        'lowercase': 'lowercase',
        'capitalize': 'capitalize',
        'normal-case': 'none'
    };
    
    if (textTransformMap[className]) {
        return { 'text-transform': textTransformMap[className] };
    }
    
    // 文本溢出
    const textOverflowMap = {
        'truncate': 'ellipsis',
        'text-ellipsis': 'ellipsis',
        'text-clip': 'clip'
    };
    
    if (textOverflowMap[className]) {
        if (className === 'truncate') {
            // truncate 需要配合其他属性使用
            return {
                'overflow': 'hidden',
                'text-overflow': 'ellipsis',
                'white-space': 'nowrap'
            };
        }
        return { 'text-overflow': textOverflowMap[className] };
    }
    
    // 空白字符处理
    const whiteSpaceMap = {
        'whitespace-normal': 'normal',
        'whitespace-nowrap': 'nowrap',
        'whitespace-pre': 'pre',
        'whitespace-pre-line': 'pre-line',
        'whitespace-pre-wrap': 'pre-wrap'
    };
    
    if (whiteSpaceMap[className]) {
        return { 'white-space': whiteSpaceMap[className] };
    }
    
    // lines 属性 - text 组件专有样式，设置文本组件最大行数
    // 平台兼容性：Android 3.9+, iOS 4.11+, HarmonyOS 4.61+, Web/小程序 不支持
    const linesMatch = className.match(/^lines-(.+)$/);
    if (linesMatch) {
        const value = linesMatch[1];
        
        // 检查是否为有效的整数值
        if (utils.isNumber(value) && parseInt(value) >= 0) {
            const linesValue = parseInt(value);
            
            // 仅在支持的平台生成 lines 属性
            if (platform === 'APP-PLUS' || platform === 'APP-ANDROID' || 
                platform === 'APP-IOS' || platform === 'app' ||
                platform === 'MP-HARMONY' || platform === 'harmony') {
                return { 'lines': linesValue === 0 ? -1 : linesValue };  // 0转换为-1（不限制）
            }
            // Web/小程序平台不支持 lines 属性，返回 null 避免生成无效CSS
            else {
                return null;
            }
        }
    }
    
    // lines 预设值
    const linesPresetMap = {
        'lines-none': -1,    // 不限制行数
        'lines-clamp': 1,    // 单行显示
        'lines-clamp-2': 2,  // 两行显示
        'lines-clamp-3': 3,  // 三行显示
        'lines-clamp-4': 4,  // 四行显示
        'lines-clamp-5': 5,  // 五行显示
        'lines-clamp-6': 6   // 六行显示
    };
    
    if (linesPresetMap[className]) {
        const linesValue = linesPresetMap[className];
        
        // 仅在支持的平台生成 lines 属性
        if (platform === 'APP-PLUS' || platform === 'APP-ANDROID' || 
            platform === 'APP-IOS' || platform === 'app' ||
            platform === 'MP-HARMONY' || platform === 'harmony') {
            return { 'lines': linesValue };
        }
        // Web/小程序平台不支持 lines 属性，返回 null 避免生成无效CSS
        else {
            return null;
        }
    }
    
    // text-ellipsis-*num 和 text-ellipsis-*[num] 功能 - 使用专用模块处理
    // 支持条件编译生成跨平台CSS
    const textEllipsisResult = processTextEllipsisRules(className, { 
        platform, 
        h5Unit, 
        remBase, 
        generateConditional: options.generateConditional || false,
        compileAllPlatforms: options.compileAllPlatforms !== false
    });
    if (textEllipsisResult) {
        return textEllipsisResult;
    }
    
    return null;
} 